import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * 动态数组
 */
public class DynamicArray implements Iterable<Integer> {
    /**
     * 动态数组
     */
    private int size = 0;  //逻辑大小
    private int capacity = 8;  //容量
    private int[] array = new int[capacity];

    public void addLast(int element) {
        array[size] = 0;
        size++;
    }

    /**
     * 向 动态数组  添加元素
     *
     * @param index
     * @param element
     */
    public void add(int index, int element) {
        //检查是否扩容
        checkAndGrow();
        if (index >= 0 && index < size) {  //超过size 数组元素连续不起来
            //将要插入位置的元素 及他后面的元素 往后移
            System.arraycopy(array,      //要copy的原始数组
                    index,               //开始copy的位置
                    array,              //copy后的目标数组
                    index + 1,          //copy目标数组的 起始位置
                    size - index        //copy几个元素
            );
        }
//            // 插入元素
//            array[index] = element;
//            // size加1
//            size++;
//        }else  if (index == size){ 想等说明在末尾了，不用copy元素直接放到末尾即可
//            // 插入元素
//            array[index] = element;
//            // size加1
//            size++;
//        }       //冗余  优化
        // 插入元素
        array[index] = element;
        // size加1
        size++;
    }

    /**
     * 获取动态数组的元素
     */
    public int get(int index) {   //要获取 元素的  数组下表 不能大于 size   [0,size)
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
        return array[index];
    }

    /**
     * 遍历数组， 并根据要求处理数据
     */
    public void foreach(Consumer<Integer> consumer) {  //有参数 无返回值 用 consumer
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }


    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() {   //判断有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() {  //返回当前元素，并移动到下一个元素
                return array[i++]; //后++， 先返回array[i] 后 ，i递增1
            }
        };
    }

    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }

    public int remove(int index) {
        int removed = array[index];
        if (index < size - 1) {    //index
            System.arraycopy(array,  //数据 原数组
                    index + 1,   //从index+1 开始copy
                    array,   //copy到到目的数组
                    index,  //copy到开始位置
                    size - index - 1 //结束位置
            );
        }
        size--;
        return removed;
    }

    private void checkAndGrow() {
        //容量检查
        if (size == 0) {
            array = new int[capacity];
        } else if (size == capacity) {
            //扩容
            capacity += capacity >> 1;
            int[] arrayNew = new int[capacity];
            System.arraycopy(array, 0, arrayNew, 0, size);
            array = arrayNew;
        }
    }




    public static void main(String[] args) {
        DynamicArray dynamicArray = new DynamicArray();
        dynamicArray.add(0, 0);
        dynamicArray.add(1, 1);
        dynamicArray.add(2, 2);
        dynamicArray.add(3, 3);

        dynamicArray.foreach(item -> {
            System.out.println(item);

        });

        for (Integer item : dynamicArray) {  // 增强for循环 会调用 DynamicArray 的 hasNext() 和  next() 方法
            System.out.println(item);
        }
        dynamicArray.remove(2);
        dynamicArray.stream().forEach(System.out::println);

        for (int i = 3;i<=17;i++){
            dynamicArray.add(i,i);
        }
        dynamicArray.foreach(System.out::println);
    }
}
